# -*- coding: utf-8 -*-
# appengine imports
from google.appengine.ext import db
from google.appengine.api import memcache
from google.appengine.ext.webapp import template

#python imports
import cgi, sys, random, hashlib, urllib, os
from datetime import datetime

#local imports
from baserequesthandler import BaseRequestHandler, BesucherHandler
from quizz.models import QAufgabe, Loesung, get_policy 
from benutzer.models.besucher import Besucher
from quizz.zeit import get_bearbeitungszeit
from einstellungen import APPLICATION_HOST

from facebookclient import app_id, FacebookHandler

# suchen
from whoosh import store
from whoosh.fields import Schema, STORED, ID, KEYWORD, TEXT
from whoosh.index import getdatastoreindex
from whoosh.qparser import QueryParser, MultifieldParser
import logging

#SEARCHSCHEMA = Schema(frage=TEXT(stored=True), tipp=TEXT(stored=True), akey=ID(stored=True))



#todo: memcache irgendwie einbauen?????

class Handler(FacebookHandler):
  def get_embed_code(self, template_values):
    """ Gibt html-Code zum Einbetten als String aus.
    """
    directory = os.path.dirname(__file__).rstrip('/quizz')
    #directory.rstrip('/quizz')
    path = os.path.join(directory, os.path.join('templates', 'quizz/embed_aufgabe.html'))
 
    html_code = template.render(path, template_values)

    return html_code

  def _compute_cookie_value(self):
    # computed cookie value:
    md5 = hashlib.md5()
    md5.update('%s %s %s' % (self.request.remote_addr, self.request.headers['User-Agent'], 'ji32340' ))
    ccv = md5.hexdigest()
    return ccv

  def get_feedback(self):
    try:
      previous = self.read_cookie('previous')
    except KeyError:
      return None

    feedback = {}
    besucher = self.get_besucher(history_append=False)
    h = besucher.get_history('POST')
    
    if len(h)>0 and previous:
      #cookie fuer naechste mal loeschen:
      self.delete_cookie('previous')
      richtig = h[-1][3]
      pktegew = h[-1][4]
      if richtig:
        feedback['color'] = 'green'
        feedback['text'] =  'richtig! +%0.1fP'.rjust(7) % pktegew
      else:
        feedback['color'] = 'red'
        feedback['text'] =  'falsch'
    else:
      feedback = None

    return feedback


  def get(self):
    akey = self.request.get('akey')
    #antworten = [('a', '2+3'), ('c','4'),...]: weil es mit django schwer ist dictionarys anzusprechen.
    
    
    ##########
    aufgabe = QAufgabe.gql('WHERE akey = :1', akey).get()
    if aufgabe is not None:
      # alte Aufgaben indexieren, falls nicht schon geschehen:
      # nur solange behalten, bis alle alten aufgaben indexiert wurden
      #ix = getdatastoreindex("QAufgabe", schema=SEARCHSCHEMA)
      #parser = QueryParser("akey", schema = ix.schema)
      #q = parser.parse(akey)
      #results = ix.searcher().search(q)
      #if not results: # d.h. wurde noch nicht indexiert:
      #  ix = getdatastoreindex("QAufgabe", schema=SEARCHSCHEMA)
      #  writer = ix.writer()
      #  writer.add_document(frage= unicode(aufgabe.frage), akey=u"%s" % akey, tipp = aufgabe.tipp)
      #  writer.commit()

      antworten = aufgabe.get_antworten(format='list')     
      # ein kleines Experiment, um die Aufgaben 'leichter' zu machen : weniger Antwortsmoeglichkeiten
      #loesungen = aufgabe.get_loesungen()
      #a = random.choice(set([a[0] for a in antworten]).difference(loesungen)) # nimm nur eine Antwort raus
      
    else:
      self.redirect('/') #irgendwas stimmt nicht, keine aufgabe gefunden --> zur Startseite
      return
    ##########

    besucher = self.get_besucher()   

    anz_bearbeitet = besucher.anz_bearbeitet(akey)
    anz_falsch_gepostet = besucher.anz_falsch_gepostet(akey)
    #if anz_falsch_gepostet > 0:
    # versuche pdf zu finden, wenn es keine gibt, dann auch kein kauflink
    loesung = Loesung.gql('where akey = :1', akey).get()
    if loesung is not None and loesung.pdf:
      kauflink = True
    else:
      kauflink = False

    if loesung is not None and loesung.video_hochgeladen:
      loesungsvideo = True
    else:
      loesungsvideo = False
    #else:
    #  kauflink_anzeigen = False

    random.shuffle(antworten) # durcheinanderbringen der Antworten

    r = random.random()
    if r <= 1.0/3.0+1.0/3.0*besucher.get_fitness(): # ein Besucher, der alle Aufgaben loesen kann, sieht die Bearbeitungszeit in 1 von 3 Aufgaben, ein Besucher, der keine Aufgaben loesen kann, sieht die Bearbeitungszeit in 1 von 6 Aufgaben
      bearbeitungszeit = get_bearbeitungszeit(aufgabe.bearbeitungs_zeiten,besucher.get_fitness())
    else:
      bearbeitungszeit = 0

    bearbeitet = int(aufgabe.bearbeitet)
    richtig_bearbeitet = int(aufgabe.richtig_bearbeitet)

    besucher_bearbeitet = len(besucher.history_POST)
    besucher_richtig = besucher.anz_richtig()

    if besucher_bearbeitet > 0:
      drucken_bearbeitet = True
    else:
      drucken_bearbeitet = False
    if besucher_richtig > 0:
      drucken_richtig = True
    else:
      drucken_richtig = False

    warp_akey = random.choice(aufgabe.links) # zufaellige Aufgabe, wenn der Besucher auf >> klickt.

    feedback = self.get_feedback() # wie wurde die letzte Aufgabe bearbeitet?

    if aufgabe.titel is not None:
      titel = aufgabe.titel
    else:
      titel = ''

    template_values = {
       'fb_current_user' : self.current_user,
       'facebook_app_id': app_id,
       'titel' : titel,
       'feedback' : feedback,
       'warp_akey' : warp_akey,
       'loesungsvideo' : loesungsvideo,
       'drucken_richtig' : drucken_richtig,
       'drucken_bearbeitet' : drucken_bearbeitet,
       'besucher_bearbeitet': besucher_bearbeitet,
       'besucher_richtig': besucher_richtig,
       'bearbeitet' : bearbeitet,
       'richtig_bearbeitet' : richtig_bearbeitet,
       'bearbeitungszeit': bearbeitungszeit,
       'url' : urllib.quote(self.request.url),
       'tipp' : aufgabe.tipp,
       'hinweis': aufgabe.hinweis(),
       'akey' : aufgabe.akey,
       'kauflink' : kauflink,
       'pfeil': 10*int(aufgabe.zu_gewinnen(anz_bearbeitet)),
       'aufg': aufgabe,
       'sgrad': aufgabe.get_sgrad(),
       'pluspunkte':  "%0.1f".rjust(7) % aufgabe.zu_gewinnen(anz_bearbeitet),
       #'minuspunkte': "%0.1f".rjust(7) % aufgabe.zu_verlieren(anz_bearbeitet),
       'punktestand': "%0.1f".rjust(7) % besucher.get_punktestand(),
       'antworten':  antworten,
       'leona_server': APPLICATION_HOST
    }

    embed_code = self.get_embed_code(template_values) 
    template_values['embed_code'] = embed_code

    #todo: besser machen: eigenen Handler mit Url zum einbetten schreiben
    embed = self.request.get('embed')
    if embed == akey:
      self.response.out.write(self.get_embed_code(template_values))
    else:
      self.generate('quizz/aufgabe.html', template_values)
    return

  def post(self):
    akey = cgi.escape(self.request.get('akey'))

    meine_antwort = set([cgi.escape(antwort) for antwort in self.request.get_all('meine_antwort')])
    #meine_antwort = set(['b'])

    ##########
    aufgabe = QAufgabe.gql('WHERE akey = :1', akey).get()
    if aufgabe is None:
      self.redirect('/') #irgendwas stimmt nicht, keine aufgabe gefunden --> zur Startseite

    
    ##########


    ###########
    cv = self.read_cookie('_abid')
    if cv:
      #self.response.out.write('gleich')
      besucher = Besucher.gql('WHERE cookie = :1', cv).get()
      if besucher is not None:
        r = aufgabe.ist_richtig(meine_antwort)
        anz_bearbeitet = besucher.anz_bearbeitet(akey)
        if r:
          pgw = + aufgabe.zu_gewinnen(anz_bearbeitet)
        else:
          pgw = 0.0 #- aufgabe.zu_verlieren(anz_bearbeitet)
        aufgabe.update_bearbeitet(meine_antwort, anz_bearbeitet)
        besucher.history_append('POST', (datetime.now(),str(akey),meine_antwort,r,pgw))
        bearbeitungszeit = besucher.get_bearbeitungszeit(akey)
        aufgabe.bearbeitungs_zeiten.append(1.0*bearbeitungszeit)
        aufgabe.put()
        besucher.put()
      else: # Posten ohne vorher als benutzer gespeichert worden zu sein ist nicht erlaubt!
        self.redirect('/quizz/aufgabe?akey=%s' % akey)
        return
    else: # Posten ohne gueltigen Cookie auch nicht erlaubt!
      self.redirect('/quizz/aufgabe?akey=%s' % akey)
      return

    ########### http://localhost:8080/quizz/aufgabe?akey=75d2ff0698cdce2c520c788f094f55ef

    ## 
    policy_akey = get_policy(akey,r)
    policy_akey_anz_richtig = besucher.anz_richtig_gepostet(policy_akey)
    rand = random.random()
    if rand <= 0.5**policy_akey_anz_richtig: # 1.0, 0.5, 0.25, 0.125
      next_akey = policy_akey
    else:
      potentielle_links = set(aufgabe.links)
      schon_geloest = set(besucher.get_richtig_gepostet())
      liste_mit_links = list(potentielle_links.difference(schon_geloest))
      if liste_mit_links:
        next_akey = random.choice(liste_mit_links)
      else: #leere liste, alle aufgaben schon bearbeitet
        next_akey = policy_akey # in diesem fall nimm die policy-variante


    self.write_cookie('previous',akey)
    self.redirect('/quizz/aufgabe?akey=%s' % next_akey)
    return

    #if aufgabe.ist_richtig(meine_antwort):
    #  potentielle_links = set(aufgabe.links)      
    #  schon_geloest = set(besucher.get_richtig_gepostet())
    #  liste_mit_links = list(potentielle_links.difference(schon_geloest))
    #  l = []
    #  for a in liste_mit_links:
    #    qaufg = QAufgabe.gql('where akey = :1', a).get()
    #    l.append((qaufg.get_sgrad(),a))
    #  l.sort() # nach schwierigkeit sortieren
    #  if l:
    #    neues_akey = l[0][1] # random.choice(liste_mit_links)
    #  else:
    #    neues_akey = akey
    #  self.redirect('/quizz/aufgabe?akey=%s' % aufgabe.get_nakey()) #neues_akey)
    #else:
    #  self.redirect('/quizz/aufgabe?akey=%s' % aufgabe.akey)
    #return

